<!DOCTYPE html>
<html>
  <head>
    <title>
      Test Interpolation for AudioParam.setValueCurveAtTime
    </title>
    <script src="../../resources/testharness.js"></script>
    <script src="../../resources/testharnessreport.js"></script>
    <script src="../resources/audit-util.js"></script>
    <script src="../resources/audit.js"></script>
    <title>
      Test Interpolation for AudioParam.setValueCurveAtTime
    </title>
  </head>
  <body>
    <script id="layout-test-code">
      // Play a constant signal through a gain node that is automated using
      // setValueCurveAtTime with a 2-element curve.  The output should be a
      // linear change.

      // Choose a sample rate that is a multiple of 128, the rendering quantum
      // size.  This makes the math work out to be nice numbers.
      let sampleRate = 25600;
      let testDurationSec = 1;
      let testDurationFrames = testDurationSec * sampleRate;

      // Where the curve starts and its duration.  This MUST be less than the
      // total rendering time.
      let curveStartTime = 256 / sampleRate;
      let curveDuration = 300 / sampleRate;
      ;
      let curveValue = 0.75;

      // At this time, the gain node goes to gain 1.  This is used to make sure
      // the value curve is propagated correctly until the next event.
      let fullGainTime = 0.75;

      // Thresholds use to determine if the test passes; these are
      // experimentally determined.  The SNR between the actual and expected
      // result should be at least |snrThreshold|.  The maximum difference
      // betwen them should not exceed |maxErrorThreshold|.
      let snrThreshold = 10000;
      let maxErrorThreshold = 0;

      let context;
      let actualResult;
      let expectedResult;

      let audit = Audit.createTaskRunner();

      // Array of test configs.  Each config must specify curveStartTime,
      // curveDuration, curveLength, fullGainTime, maxErrorThreshold, and
      // snrThreshold.
      let testConfigs = [
        {
          // The main test
          curveStartTime: 256 / sampleRate,
          curveDuration: 300 / sampleRate,
          curveLength: 2,
          fullGainTime: 0.75,
          maxErrorThreshold: 5.9605e-8,
          snrThreshold: 171.206
        },
        {
          // Increase the curve length
          curveStartTime: 256 / sampleRate,
          curveDuration: 300 / sampleRate,
          curveLength: 3,
          fullGainTime: 0.75,
          maxErrorThreshold: 5.9605e-8,
          snrThreshold: 171.206
        },
        {
          // Increase the curve length
          curveStartTime: 256 / sampleRate,
          curveDuration: 300 / sampleRate,
          curveLength: 16,
          fullGainTime: 0.75,
          maxErrorThreshold: 5.9605e-8,
          snrThreshold: 170.892
        },
        {
          // Increase the curve length
          curveStartTime: 256 / sampleRate,
          curveDuration: 300 / sampleRate,
          curveLength: 100,
          fullGainTime: 0.75,
          maxErrorThreshold: 1.1921e-7,
          snrThreshold: 168.712
        },
        {
          // Corner case with duration less than a frame!
          curveStartTime: 256 / sampleRate,
          curveDuration: 0.25 / sampleRate,
          curveLength: 2,
          fullGainTime: 0.75,
          maxErrorThreshold: 0,
          snrThreshold: 10000
        },
        {
          // Short duration test
          curveStartTime: 256 / sampleRate,
          curveDuration: 2 / sampleRate,
          curveLength: 2,
          fullGainTime: 0.75,
          maxErrorThreshold: 0,
          snrThreshold: 10000
        },
        {
          // Short duration test with many points.
          curveStartTime: 256 / sampleRate,
          curveDuration: 2 / sampleRate,
          curveLength: 8,
          fullGainTime: 0.75,
          maxErrorThreshold: 0,
          snrThreshold: 10000
        },
        {
          // Long duration, big curve
          curveStartTime: 256 / sampleRate,
          curveDuration: .5,
          curveLength: 1000,
          fullGainTime: 0.75,
          maxErrorThreshold: 5.9605e-8,
          snrThreshold: 152.784
        }
      ];

      // Creates a function based on the test config that is suitable for use by
      // defineTask().
      function createTaskFunction(config) {
        return function(task, should) {
          runTest(should, config).then(() => task.done());
        };
      }

      // Define a task for each config, in the order listed in testConfigs.
      for (let k = 0; k < testConfigs.length; ++k) {
        let config = testConfigs[k];
        let name = k + ':curve=' + config.curveLength +
            ',duration=' + (config.curveDuration * sampleRate);
        audit.define(name, createTaskFunction(config));
      }

      // Simple test from crbug.com/441471.  Makes sure the end points and the
      // middle point are interpolated correctly.
      audit.define('crbug-441471', (task, should) => {
        // Any sample rate should work; we pick something small such that the
        // time end points are on a sampling point.
        let context = new OfflineAudioContext(1, 5000, 5000)

            // A constant source
            let source = context.createBufferSource();
        source.buffer = createConstantBuffer(context, 1, 1);
        source.loop = true;

        let gain = context.createGain();

        let startTime = 0.7;
        let duration = 0.2;

        // Create the curve.  The interpolated result should be just a straight
        // line from -1 to 1 from time startTime to startTime + duration.

        let c = new Float32Array(3);
        c[0] = -1;
        c[1] = 0;
        c[2] = 1;
        gain.gain.setValueCurveAtTime(c, startTime, duration);
        source.connect(gain);
        gain.connect(context.destination);
        source.start();

        context.startRendering()
            .then(function(renderedBuffer) {
              let data = renderedBuffer.getChannelData(0);
              let endTime = startTime + duration;
              let midPoint = (startTime + endTime) / 2;

              should(
                  data[timeToSampleFrame(startTime, context.sampleRate)],
                  'Curve value at time ' + startTime)
                  .beEqualTo(c[0]);
              // Due to round-off, the value at the midpoint is not exactly zero
              // on arm64.  See crbug.com/558563.  The current value is
              // experimentally determined.
              should(
                  data[timeToSampleFrame(midPoint, context.sampleRate)],
                  'Curve value at time ' + midPoint)
                  .beCloseTo(0, {threshold: Math.pow(2, -51)});
              should(
                  data[timeToSampleFrame(endTime, context.sampleRate)],
                  'Curve value at time ' + endTime)
                  .beEqualTo(c[2]);
            })
            .then(() => task.done());
      });

      function runTest(should, config) {
        context = new OfflineAudioContext(1, testDurationFrames, sampleRate);

        // A constant audio source of value 1.
        let source = context.createBufferSource();
        source.buffer = createConstantBuffer(context, 1, 1);
        source.loop = true;

        // The value curve for testing.  Just to make things easy for testing,
        // make the curve a simple ramp up to curveValue.
        // TODO(rtoy): Maybe allow more complicated curves?
        let curve = new Float32Array(config.curveLength);
        for (let k = 0; k < config.curveLength; ++k) {
          curve[k] = curveValue / (config.curveLength - 1) * k;
        }

        // A gain node that is to be automated using setValueCurveAtTime.
        let gain = context.createGain();
        gain.gain.value = 0;
        gain.gain.setValueCurveAtTime(
            curve, config.curveStartTime, config.curveDuration);
        // This is to verify that setValueCurveAtTime ends appropriately.
        gain.gain.setValueAtTime(1, config.fullGainTime);

        source.connect(gain);
        gain.connect(context.destination);
        source.start();

        // Some consistency checks on the test parameters
        let prefix = 'Length ' + config.curveLength + ', duration ' +
            config.curveDuration;
        should(
            config.curveStartTime + config.curveDuration,
            prefix + ': Check: Curve end time')
            .beLessThanOrEqualTo(testDurationSec);
        should(config.fullGainTime, prefix + ': Check: Full gain start time')
            .beLessThanOrEqualTo(testDurationSec);
        should(config.fullGainTime, prefix + ': Check: Full gain start time')
            .beGreaterThanOrEqualTo(
                config.curveStartTime + config.curveDuration);

        // Rock and roll!
        return context.startRendering().then(checkResult(should, config));
      }

      // Return a function to check that the rendered result matches the
      // expected result.
      function checkResult(should, config) {
        return function(renderedBuffer) {
          let success = true;

          actualResult = renderedBuffer.getChannelData(0);
          expectedResult = computeExpectedResult(config);

          // Compute the SNR and max absolute difference between the actual and
          // expected result.
          let SNR = 10 * Math.log10(computeSNR(actualResult, expectedResult));
          let maxDiff = -1;
          let posn = -1;

          for (let k = 0; k < actualResult.length; ++k) {
            let diff = Math.abs(actualResult[k] - expectedResult[k]);
            if (maxDiff < diff) {
              maxDiff = diff;
              posn = k;
            }
          }

          let prefix = 'Curve length ' + config.curveLength + ', duration ' +
              config.curveDuration;
          should(SNR, prefix + ': SNR')
              .beGreaterThanOrEqualTo(config.snrThreshold);

          should(maxDiff, prefix + ': Max difference')
              .beLessThanOrEqualTo(config.maxErrorThreshold);
        }
      }

      // Compute the expected result based on the config settings.
      function computeExpectedResult(config) {
        // The automation curve starts at |curveStartTime| and has duration
        // |curveDuration|.  So, the output should be zero until curveStartTime,
        // linearly ramp up from there to |curveValue|, and then be constant 1
        // from then to the end of the buffer.

        let expected = new Float32Array(testDurationFrames);

        let curveStartFrame = config.curveStartTime * sampleRate;
        let curveEndFrame =
            (config.curveStartTime + config.curveDuration) * sampleRate;
        let fullGainFrame = config.fullGainTime * sampleRate;

        let k;

        // Zero out the start.
        for (k = 0; k < curveStartFrame; ++k)
          expected[k] = 0;

        // Linearly ramp now.  This assumes that the actual curve used is a
        // linear ramp, even if there are many curve points.
        let stepSize = curveValue / (config.curveDuration * sampleRate);
        for (; k < curveEndFrame; ++k)
          expected[k] = stepSize * (k - curveStartFrame);

        // Hold it constant until the next event
        for (; k < fullGainFrame; ++k)
          expected[k] = curveValue;

        // Amplitude is one for the rest of the test.
        for (; k < testDurationFrames; ++k)
          expected[k] = 1;

        return expected;
      }

      audit.run();
    </script>
  </body>
</html>
